package org.dxy.trigger.http;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dxy.api.dto.*;
import org.dxy.api.response.R;
import org.dxy.infrastructure.persistent.db.mybatispuls.po.query.ProcessViewPo;
import org.dxy.trigger.http.service.ProcessApplicationService;
import org.springdoc.core.annotations.ParameterObject;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @description: 工序控制器
 * @author: dxy
 * @createTime: 2025/6/22 23:47
 */
@Slf4j
@RestController
@RequestMapping("/api/process")
@RequiredArgsConstructor
public class ProcessController {
    private final ProcessApplicationService processApplicationService;

    /**
     * 创建工序
     * @param dto 工序创建请求DTO
     * @return 操作结果
     */
    @PostMapping("/create")
    public R<Long> create(@Validated @RequestBody CreateProcessRequestDto dto) {
        return processApplicationService.create(dto);
    }

    /**
     * 开始执行工序
     * @param dto 工序开始执行请求DTO
     * @return 操作结果
     * @date: 2025/6/22 23:47
     * @auther dxy
     */
    @PostMapping("/start")
    public R<Void> start(@Validated @RequestBody StartProcessRequestDto dto) {
        return processApplicationService.start(dto);
    }

    /**
     * 暂停工序
     * @param dto 工序暂停请求DTO
     * @return 操作结果
     * @date: 2025/6/22 23:47
     * @auther dxy
     */
    @PostMapping("/pause")
    public R<Void> pause(@Validated @RequestBody PauseProcessRequestDto dto) {
        return processApplicationService.pause(dto);
    }

    /**
     * 恢复工序
     * @param dto 工序恢复请求DTO
     * @return 操作结果
     * @date: 2025/6/22 23:47
     * @auther dxy
     */
    @PostMapping("/resume")
    public R<Void> resume(@Validated @RequestBody ResumeProcessRequestDto dto) {
        return processApplicationService.resume(dto);
    }

    /**
     * 完成工序
     * @param dto 工序完成请求DTO
     * @return 操作结果
     * @date: 2025/6/22 23:47
     * @auther dxy
     */
    @PostMapping("/complete")
    public R<Void> complete(@Validated @RequestBody CompleteProcessRequestDto dto) {
        return processApplicationService.complete(dto);
    }

    /**
     * 变更工序步骤
     * @param dto 工序步骤变更请求DTO
     * @return 操作结果
     * @date: 2025/6/22 23:47
     * @auther dxy
     */
    @PostMapping("/changeStep")
    public R<Void> changeStep(@Validated @RequestBody ChangeProcessStepRequest dto) {
        return processApplicationService.changeStep(dto);
    }

    /**
     * 工序质量检测
     * @param dto 工序质量检测请求DTO
     * @return 操作结果
     * @date: 2025/6/22 23:47
     * @auther dxy
     */
    @PostMapping("/checkQuality")
    public R<Void> checkQuality(@Validated @RequestBody CheckProcessQualityRequestDto dto) {
        return processApplicationService.checkQuality(dto);
    }

    /**
     * 工序挂起
     * @param dto 工序挂起请求DTO
     * @return 操作结果
     * @date: 2025/6/22 23:47
     * @auther dxy
     */
    @PostMapping("/hold")
    public R<Void> hold(@Validated @RequestBody HoldProcessRequestDto dto) {
        return processApplicationService.hold(dto);
    }

    /**
     * 工序解除挂起
     * @param dto 工序解除挂起请求DTO
     * @return 操作结果
     * @date: 2025/6/22 23:47
     * @auther dxy
     */
    @PostMapping("/release")
    public R<Void> release(@Validated @RequestBody ReleaseProcessRequestDto dto) {
        return processApplicationService.release(dto);
    }

    /**
     * 工序返工
     * @param dto 工序返工请求DTO
     * @return 操作结果
     */
    @PostMapping("/rework")
    public R<Void> rework(@Validated @RequestBody ReworkProcessRequestDto dto) {
        return processApplicationService.rework(dto);
    }

    /**
     * 工序测量参数记录
     * @param dto 工序测量参数记录请求DTO
     * @return 操作结果
     */
    @PostMapping("/recordMeasurement")
    public R<Void> recordMeasurement(@Validated @RequestBody RecordProcessMeasurementRequestDto dto) {
        return processApplicationService.recordMeasurement(dto);
    }



    /**
     * 工序分配
     * @param dto 工序分配请求DTO
     * @return 操作结果
     */
    @PostMapping("/assign")
    public R<Void> assign(@Validated @RequestBody AssignProcessRequest dto) {
        return processApplicationService.assign(dto);
    }

    /**
     * 分页查询工序列表
     * @param page 分页参数（页码、每页大小等）
     * @param query 过滤条件（工序编码、工序名称、状态等）
     * @return 分页的工序列表响应
     * @date: 2025/8/9 
     * @author dxy
     */
    @GetMapping("/list")
    public R<Page<ProcessViewPo>> list(
            @ParameterObject Page<ProcessViewPo> page,
            @ParameterObject ProcessViewPo query) {
        return processApplicationService.list(page, query);
    }

    /**
     * 查询工序详情
     * @param processId 工序ID
     * @return 返回工序详情或失败响应
     * @date: 2025/8/9
     * @author dxy
     */
    @GetMapping("/{processId}")
    public R<ProcessViewPo> getById(@PathVariable Long processId) {
        return processApplicationService.getById(processId);
    }

    /**
     * 根据状态分页查询工序
     * @param page 分页参数
     * @param status 工序状态
     * @return 分页的工序列表响应
     * @date: 2025/8/9
     * @author dxy
     */
    @GetMapping("/status/{status}")
    public R<Page<ProcessViewPo>> getByStatus(
            @ParameterObject Page<ProcessViewPo> page,
            @PathVariable String status) {
        return processApplicationService.getByStatus(page, status);
    }

    /**
     * 删除单个工序
     * @param processId 工序ID，必须为正整数
     * @return 返回删除成功或失败的响应
     * @apiNote 只有处于已创建、已完成状态的工序才能被删除
     * @date: 2025/8/9
     * @author dxy
     */
    @DeleteMapping("/{processId}")
    public R<Void> delete(@PathVariable("processId") Long processId) {
        log.info("删除工序请求 - 工序ID: {}", processId);
        
        if (processId == null || processId <= 0) {
            log.warn("无效的工序ID: {}", processId);
            return R.fail("工序ID不能为空且必须为正整数");
        }
        
        try {
            R<Void> result = processApplicationService.delete(processId);
            if (result.isOk()) {
                log.info("工序删除成功 - 工序ID: {}", processId);
            } else {
                log.warn("工序删除失败 - 工序ID: {}, 错误信息: {}", processId, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("工序删除异常 - 工序ID: {}", processId, e);
            return R.fail("工序删除失败: " + e.getMessage());
        }
    }

    /**
     * 批量删除工序
     * @param processIds 工序ID列表，ID列表不能为空且每个ID必须为正整数
     * @return 返回批量删除成功或失败的响应
     * @apiNote 只有处于已创建、已完成状态的工序才能被删除，如果列表中包含不可删除的工序，整个操作将失败
     * @date: 2025/8/9
     * @author dxy
     */
    @DeleteMapping("/batch")
    public R<Void> batchDelete(@RequestBody List<Long> processIds) {
        log.info("批量删除工序请求 - 工序ID列表: {}", processIds);
        
        if (processIds == null || processIds.isEmpty()) {
            log.warn("批量删除请求参数无效: 工序ID列表为空");
            return R.fail("工序ID列表不能为空");
        }
        
        // 验证ID列表中的每个ID都是有效的正整数
        for (Long id : processIds) {
            if (id == null || id <= 0) {
                log.warn("批量删除请求参数无效: 包含无效的工序ID {}", id);
                return R.fail("工序ID列表中包含无效的ID: " + id);
            }
        }
        
        if (processIds.size() > 100) {
            log.warn("批量删除请求参数无效: 一次删除的工序数量过多 {}", processIds.size());
            return R.fail("一次最多只能删除100个工序");
        }
        
        try {
            R<Void> result = processApplicationService.batchDelete(processIds);
            if (result.isOk()) {
                log.info("批量删除工序成功 - 删除数量: {}", processIds.size());
            } else {
                log.warn("批量删除工序失败 - 工序ID列表: {}, 错误信息: {}", processIds, result.getMsg());
            }
            return result;
        } catch (Exception e) {
            log.error("批量删除工序异常 - 工序ID列表: {}", processIds, e);
            return R.fail("批量删除工序失败: " + e.getMessage());
        }
    }
} 